package com.by.toolkit.utils;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;

/**
 * 描述：
 *
 * @author liujun
 * @date 2023年06月17 11:17 AM
 */
public class ByIfNotEmptyUtil {
    private ByIfNotEmptyUtil() {

    }


    /**
     * @param str              str
     * @param notEmptySupplier 不为空时执行
     * @param defaultVal       为空时返回
     * @return 返回
     */
    public static <T> T getIfNotEmpty(String str, Supplier<T> notEmptySupplier, T defaultVal) {
        if (StringUtils.isNotEmpty(str)) {
            return notEmptySupplier.get();
        } else {
            return defaultVal;
        }
    }


    /**
     * @param collection       集合
     * @param notEmptySupplier 不为空时执行
     * @param defaultVal       为空时返回
     * @return 返回
     */
    public static <T> T getIfNotEmpty(Collection<?> collection, Supplier<T> notEmptySupplier, T defaultVal) {
        if (CollectionUtils.isNotEmpty(collection)) {
            return notEmptySupplier.get();
        } else {
            return defaultVal;
        }
    }




    /**
     * @param str              str
     * @param emptySupplier    为空时执行
     * @param defaultVal       不为空时返回
     * @return 返回
     */
    public static <T> T getIfEmpty(String str, Supplier<T> emptySupplier, T defaultVal) {
        if (StringUtils.isEmpty(str)) {
            return emptySupplier.get();
        } else {
            return defaultVal;
        }
    }


    /**
     * @param collection       集合
     * @param emptySupplier    为空时执行
     * @param defaultVal       为空时返回
     * @return 返回
     */
    public static <T> T getIfEmpty(Collection<?> collection, Supplier<T> emptySupplier, T defaultVal) {
        if (CollectionUtils.isEmpty(collection)) {
            return emptySupplier.get();
        } else {
            return defaultVal;
        }
    }

    /**
     * @param string           str
     * @param notEmptySupplier 不为空时执行
     * @param emptySupplier    为空时执行
     * @return 返回
     */
    public static <T> T getIfNotEmptyOrElse(String string, Supplier<T> notEmptySupplier, Supplier<T> emptySupplier) {
        if (StringUtils.isNotEmpty(string)) {
            return notEmptySupplier.get();
        } else {
            return emptySupplier.get();
        }
    }


    /**
     * @param collection       str
     * @param notEmptySupplier 不为空时执行
     * @param emptySupplier    为空时执行
     * @return 返回
     */
    public static <T> T getIfNotEmptyOrElse(Collection<?> collection, Supplier<T> notEmptySupplier,
                                            Supplier<T> emptySupplier) {
        if (CollectionUtils.isNotEmpty(collection)) {
            return notEmptySupplier.get();
        } else {
            return emptySupplier.get();
        }
    }


    /**
     * @param str              str
     * @param notEmptyRunnable 不为空时执行
     */
    public static void doIfNotEmpty(String str, ByRunnable notEmptyRunnable) {
        if (StringUtils.isNotEmpty(str)) {
            notEmptyRunnable.run();
        }
    }

    /**
     * @param str str
     * @param notEmptyConsumer
     */
    public static void doIfNotEmpty(String str, Consumer<String> notEmptyConsumer) {
        if (StringUtils.isNotEmpty(str)) {
            notEmptyConsumer.accept(str);
        }
    }


    /**
     * @param collection       str
     * @param notEmptyRunnable 不为空时执行
     */
    public static void doIfNotEmpty(Collection<?> collection, ByRunnable notEmptyRunnable) {
        if (CollectionUtils.isNotEmpty(collection)) {
            notEmptyRunnable.run();
        }
    }

    /**
     * @param collection 集合
     * @param notEmptyConsumer 不为空时执行
     */
    public static<T> void doIfNotEmptyList(List<T> collection, Consumer<List<T>> notEmptyConsumer) {
        if (CollectionUtils.isNotEmpty(collection)) {
            notEmptyConsumer.accept(collection);
        }
    }



    /**
     * @param str              str
     * @param emptyRunnable 为空时执行
     */
    public static void doIfEmpty(String str, ByRunnable emptyRunnable) {
        if (StringUtils.isEmpty(str)) {
            emptyRunnable.run();
        }
    }


    /**
     * @param collection       str
     * @param emptyRunnable    为空时执行
     */
    public static void doIfEmpty(Collection<?> collection, ByRunnable emptyRunnable) {
        if (CollectionUtils.isEmpty(collection)) {
            emptyRunnable.run();
        }
    }



    /**
     * @param str              str
     * @param notEmptyRunnable 不为空执行
     * @param emptyRunnable    为空执行
     */
    public static void doIfNotEmptyOrElse(String str, ByRunnable notEmptyRunnable, ByRunnable emptyRunnable) {
        if (StringUtils.isNotEmpty(str)) {
            notEmptyRunnable.run();
        } else {
            emptyRunnable.run();
        }
    }


    /**
     * @param collection       str
     * @param notEmptyRunnable 不为空执行
     * @param emptyRunnable    为空执行
     */
    public static void doIfNotEmptyOrElse(Collection<?> collection, ByRunnable notEmptyRunnable,
                                          ByRunnable emptyRunnable) {
        if (CollectionUtils.isNotEmpty(collection)) {
            notEmptyRunnable.run();
        } else {
            emptyRunnable.run();
        }
    }

    /**
     * @param string           str
     * @param notEmptySupplier 不为空执行
     * @param emptySupplier    为空执行
     * @param <T>              泛型
     * @return 返回
     */
    public static void doIfNotEmptyOrElseThrow(String string, Consumer<String> notEmptySupplier,
                                                 Supplier<? extends RuntimeException> emptySupplier) {
        if (StringUtils.isNotEmpty(string)) {
            notEmptySupplier.accept(string);
        } else {
            throw emptySupplier.get();
        }
    }

    /**
     * @param string           str
     * @param notEmptySupplier 不为空执行
     * @param emptySupplier    为空执行
     * @param <T>              泛型
     * @return 返回
     */
    public static <T> T getIfNotEmptyOrElseThrow(String string, Supplier<T> notEmptySupplier,
                                                 Supplier<? extends RuntimeException> emptySupplier) {
        if (StringUtils.isNotEmpty(string)) {
            return notEmptySupplier.get();
        } else {
            throw emptySupplier.get();
        }
    }


    /**
     * @param collection       str
     * @param notEmptySupplier 不为空执行
     * @param emptySupplier    为空执行
     * @param <T>              泛型
     * @return 返回
     */
    public static <T> T getIfNotEmptyOrElseThrow(Collection<?> collection, Supplier<T> notEmptySupplier,
                                                 Supplier<? extends RuntimeException> emptySupplier) {
        if (CollectionUtils.isNotEmpty(collection)) {
            return notEmptySupplier.get();
        } else {
            throw emptySupplier.get();
        }
    }

    /**
     * @param str               判断
     * @param exceptionSupplier 异常supplier
     */
    public static void throwIfEmpty(String str, Supplier<? extends RuntimeException> exceptionSupplier) {
        if (StringUtils.isEmpty(str)) {
            throw exceptionSupplier.get();
        }
    }


    /**
     * @param collection        判断
     * @param exceptionSupplier 异常supplier
     */
    public static void throwIfEmpty(Collection<?> collection, Supplier<? extends RuntimeException> exceptionSupplier) {
        if (CollectionUtils.isEmpty(collection)) {
            throw exceptionSupplier.get();
        }
    }

}
